// 智谱AI服务模块
class ZhipuAIService {
  constructor() {
    // 智谱AI API配置
    this.apiKey = ''; // 需要用户配置API密钥
    this.baseURL = 'https://open.bigmodel.cn/api/paas/v4/chat/completions';
    this.model = 'glm-4-flash';
  }

  // 设置API密钥
  setApiKey(apiKey) {
    this.apiKey = apiKey;
  }

  // 生成正则表达式的AI提示词
  createRegexPrompt(selectedText, fixedPart = '') {
    const basePrompt = 
    `为以下文本生成一个正则表达式：
    文本样本: "${selectedText}"
    固定部分: "${fixedPart}"
    要求：
    1. 分析文本的模式和结构
    2. 识别可变部分和固定部分
    3. 生成能匹配相似格式文本的正则表达式
    4. 使用适当的捕获组
    5. 考虑中文、英文、数字、特殊字符的组合
    直接返回正则表达式，不要包含任何解释或推理过程。`;
    return basePrompt;
  }

  // 调用智谱AI API生成正则表达式
  async generateRegex(selectedText, fixedPart = '') {
    console.log('🤖 开始AI正则生成...');
    console.log('输入文本:', selectedText);
    console.log('固定部分:', fixedPart);
    
    if (!this.apiKey) {
      console.error('❌ API密钥未配置');
      throw new Error('请先配置智谱AI API密钥');
    }

    if (!selectedText || !selectedText.trim()) {
      console.error('❌ 文本为空');
      throw new Error('请提供有效的文本样本');
    }

    try {
      const prompt = this.createRegexPrompt(selectedText, fixedPart);
      console.log('📝 生成的提示词:', prompt);
      
      console.log('🌐 发送API请求...');
      const response = await fetch(this.baseURL, {
        method: 'POST',
        headers: {
          'Content-Type': 'application/json',
          'Authorization': `Bearer ${this.apiKey}`
        },
        body: JSON.stringify({
          model: this.model,
          messages: [
            {
              role: 'user',
              content: prompt
            }
          ],
          temperature: 0.1,
          max_tokens: 200,
          stream: false
        })
      });

      console.log('📡 API响应状态:', response.status);
      
      if (!response.ok) {
        const errorData = await response.json();
        console.error('❌ API调用失败:', errorData);
        throw new Error(`API调用失败: ${errorData.error?.message || response.statusText}`);
      }

      const data = await response.json();
      console.log('📦 API返回数据:', data);
      
      if (!data.choices || !data.choices[0] || !data.choices[0].message) {
        console.error('❌ API返回数据格式错误:', data);
        throw new Error('API返回数据格式错误');
      }

      const message = data.choices[0].message;
      console.log('🔍 完整message对象:', JSON.stringify(message, null, 2));
      
      let regexContent = '';
      
      if (message.content && message.content.trim()) {
        regexContent = message.content.trim();
        console.log('✅ 使用content字段内容:', regexContent);
      } else {
        console.error('❌ AI回复内容为空:', message);
        window.ElMessage('❌ AI没有回复答案')
        throw new Error('响应中没有找到content内容');
      }
      
      // 清理返回的内容，提取正则表达式
      regexContent = this.cleanRegexResponse(regexContent);
      console.log('🧹 清理后的正则:', regexContent);
      
      // 验证生成的正则表达式
      this.validateRegex(regexContent);
      console.log('✅ 正则验证通过');
      
      console.log('🎉 AI正则生成成功:', regexContent);
      return regexContent;
      
    } catch (error) {
      console.error('💥 智谱AI API调用错误:', error);
      throw new Error(`生成正则表达式失败: ${error.message}`);
    }
  }

  // 清理AI返回的正则表达式内容
  cleanRegexResponse(content) {
    console.log('🧹 开始清理AI回复内容:', content);
    
    // 如果内容很长，可能是推理过程，尝试提取正则表达式
    if (content.length > 500) {
      console.log('📝 内容较长，可能包含推理过程，尝试提取正则...');
      
      // 查找可能的正则表达式模式
      const regexPatterns = [
        // 匹配被反引号包围的内容
        /`([^`]+)`/g,
        // 匹配看起来像正则的内容
        /([\\^$.*+?{}[\]|()\-]+)/g,
        // 匹配固定部分后的模式
        /Test Report\s+No\.:.*?([\\^$.*+?{}[\]|()\-]+)/g
      ];
      
      for (const pattern of regexPatterns) {
        const matches = content.match(pattern);
        if (matches) {
          for (const match of matches) {
            const cleaned = match.replace(/`/g, '').trim();
            if (this.looksLikeRegex(cleaned) && cleaned.length > 5) {
              console.log('🎯 找到可能的正则表达式:', cleaned);
              content = cleaned;
              break;
            }
          }
          if (content.length < 200) break; // 如果找到了较短的内容，说明提取成功
        }
      }
      
      // 如果还是很长，尝试基于样本生成简单正则
      if (content.length > 200) {
        console.log('⚠️ 无法从长文本中提取正则，生成默认正则');
        content = 'Test Report\\s+No\\.:\\s*([A-Z0-9]+)';
      }
    }
    
    // 移除可能的markdown代码块标记
    content = content.replace(/```[\s\S]*?```/g, (match) => {
      return match.replace(/```(?:regex|javascript|js)?\n?/g, '').replace(/```/g, '');
    });

    // 移除前后的斜杠（如果存在）
    content = content.replace(/^\/|\/[gimuy]*$/g, '');
    
    // 移除多余的空白字符
    content = content.trim();
    
    // 如果内容包含多行，取第一个看起来像正则表达式的行
    const lines = content.split('\n');
    for (const line of lines) {
      const trimmedLine = line.trim();
      if (trimmedLine && !trimmedLine.startsWith('//') && !trimmedLine.startsWith('#')) {
        // 简单验证是否看起来像正则表达式
        if (this.looksLikeRegex(trimmedLine)) {
          return trimmedLine;
        }
      }
    }
    
    return content;
  }

  // 简单检查字符串是否看起来像正则表达式
  looksLikeRegex(str) {
    // 检查是否包含正则表达式常见的字符
    const regexChars = /[\[\](){}.*+?^$|\\]/;
    return regexChars.test(str) && str.length > 2;
  }

  // 验证正则表达式的有效性
  validateRegex(regexString) {
    try {
      new RegExp(regexString);
      return true;
    } catch (error) {
      throw new Error(`生成的正则表达式无效: ${error.message}`);
    }
  }

  // 测试正则表达式是否能匹配原始文本
  testRegex(regexString, testText) {
    try {
      const regex = new RegExp(regexString, 'i');
      return regex.test(testText);
    } catch (error) {
      return false;
    }
  }

  // 获取API使用状态
  getApiStatus() {
    return {
      hasApiKey: !!this.apiKey,
      model: this.model,
      baseURL: this.baseURL
    };
  }
}

// 导出服务实例
window.ZhipuAIService = ZhipuAIService;